#!/usr/bin/python

#
# TODO: Parametrizar o tamanho do processamento, 7 ou 5 digitos, de acordo com o cliente
#

# Flag para teste unitario
flag_unit_test=0
#flag_unit_test=1

# teste unitario
if flag_unit_test==1:
	import sys
	sys.path.append("lib/log")
	sys.path.append("lib/db")
	sys.path.append("lib/comum")


import os
import glob

from log import Log
from dados import Dados
from const import Const
from executor import Executor

class Processamento:
	def __init__(self):
		self.log 	= Log()
		self.dados 	= Dados()
		self.CONST	= Const()

	def start(self):
		self.log.update('Iniciando processamento...\n')

		# Tentando reservar os processamentos
		#l=self.dados.lockProcessamento()
		p=self.dados.getProcessamento()
		#self.log.update('p:' + str(p) + '\n')

		for i in p:
			id_processamento=i[0]
			id_sistema	=i[1]
			tipo		=i[2]
			status		=i[3]
			self.log.update('####################################################################\n')
			self.log.update('processamento=' + str(id_processamento) + ' - sistema=' + str(id_sistema) + ' - tipo=' + str(tipo) + ' - status=' + str(status) + '\n')
			# Obtendo o path de processamento
			executor	=self.dados.getExecutor(id_sistema)
			id_executor	=executor[0]
			servidor	=executor[1]
			# Criando path de processamento	
			self.path 	=executor[2] + "/%07d" % (id_processamento)	
			self.log.update('executor path=' + str(self.path) + '\n')
			os.chdir(self.path)
			self.setStatus(id_processamento, id_sistema, self.CONST.PROCESSANDO)
			status=self.getStatus(id_processamento)
			self.log.update('processamento[' + str(id_processamento) + ']['+ str(status) + ']\n')
			e=Executor(id_executor, id_processamento, id_sistema)
			if(e.getStatus()==self.CONST.FINALIZADO):
				self.setStatus(id_processamento, id_sistema, self.CONST.FINALIZADO)
			else:
				self.setStatus(id_processamento, id_sistema, self.CONST.ERRO)
			self.log.update('Finalizando processamento['+ str(id_processamento) +'][status:' + str(self.getStatus(id_processamento)) + ']...\n')

			# Voltar ao estado inicial para poder continuar os testes
			if flag_unit_test==1:
				self.setStatus(id_processamento, id_sistema, self.CONST.ESPERANDO)
		# Tentando liberar os processamentos
		#l=self.dados.unlockProcessamento()
		
		
	def setStatus(self, id_processamento, id_sistema, s):
		self.dados.setProcessamentoStatus(id_processamento, id_sistema, s)
	def getStatus(self,id):
		return self.dados.getProcessamentoStatus(id)[0][0]
		
	def finish(self):
		self.log.update('Finalizando processamento...\n')

	def run(self):
		self.start()
		self.finish()

	def lockProcessamento(self, id):
		self.log.update('Lock processamento...\n')
		# Setando direito de processamento exclusivo
		id_processamento=self.dados.lockProcessamento(id)
		self.log.update("id_processamento=" + str(id_processamento) + "\n")
		# Obtendo o path de processamento
		self.executor=self.dados.getExecutor(id)
		self.servidor=self.executor[1]
		# Criando path de processamento	
		self.path = self.executor[2] + "/%07d" % (id_processamento)	
		os.makedirs(self.path)
		return id_processamento

	def getPathSistema(self, id):
		self.log.update('get Path Sistema...\n')
		# Setando direito de processamento exclusivo
		self.executor=self.dados.getExecutor(id)
		# Criando path de processamento	
		self.path = self.executor[2] 
		return self.path 

	def getPath(self):
		return self.path
#local teste
if flag_unit_test==1:
	inner=Processamento()
	inner.run()
